/*
 * @Author: Await
 * @Date: 2025-05-09 13:00:00
 * @LastEditors: Await
 * @LastEditTime: 2025-05-08 09:41:44
 * @Description: ECharts及其扩展组件的初始化与静态加载
 */

// 导入标准echarts
import * as echarts from 'echarts';

// 使用静态导入，直接全局引用
import 'echarts-gl';

// 声明全局window变量以扩展echarts属性
declare global {
  interface Window {
    echarts: typeof echarts;
  }
}

/**
 * 跟踪ECharts-GL扩展是否已加载
 */
let echartsGLLoaded = true; // 默认为true，因为使用静态导入

/**
 * 检查是否有GL相关组件
 */
export const hasGLComponents = (): boolean => {
  if (!echarts) return false;

  try {
    // 创建容器元素并设置明确的尺寸，避免尺寸警告
    const container = document.createElement('div');
    container.style.width = '100px';
    container.style.height = '100px';
    container.style.visibility = 'hidden';
    container.style.position = 'absolute';
    document.body.appendChild(container);

    // 方法1：通过系列类型检查
    const chartInstance = echarts.init(container);
    const has3DCharts = echarts.getMap && (
      typeof echarts.getMap('bar3D') !== 'undefined' ||
      typeof echarts.getMap('scatter3D') !== 'undefined' ||
      typeof echarts.getMap('line3D') !== 'undefined'
    );

    // 方法2：检查组件模型
    let hasComponents = false;
    if (typeof (echarts as any).ComponentModel?.hasClass === 'function') {
      hasComponents = (
        (echarts as any).ComponentModel.hasClass('series.bar3D') ||
        (echarts as any).ComponentModel.hasClass('series.scatter3D')
      );
    }

    // 方法3：检查echarts.gl对象
    const hasGLObject = !!(echarts as any).gl;

    // 销毁临时实例
    chartInstance.dispose();
    // 移除临时容器
    document.body.removeChild(container);

    return has3DCharts || hasComponents || hasGLObject;
  } catch (e) {
    console.warn('检查GL组件时出错:', e);
    return false;
  }
};

/**
 * 判断ECharts-GL组件是否已加载
 * @returns 是否已加载
 */
export const hasGLComponentsLoaded = (): boolean => {
  // 检查全局标志
  if (echartsGLLoaded) return true;

  // 检查echarts对象上是否有GL相关组件
  const componentsLoaded = hasGLComponents();
  if (componentsLoaded) {
    echartsGLLoaded = true;
  }

  return componentsLoaded;
};

/**
 * 确保GL模块正确初始化
 * 由于使用静态导入，此函数主要用于确认组件已正确加载
 */
const executeGLModuleLoad = async (): Promise<boolean> => {
  try {
    // 首先尝试检查是否已挂载（应该总是已挂载，因为使用了静态导入）
    if (hasGLComponentsLoaded()) {
      console.log('检测到ECharts-GL组件已加载，无需重新加载');
      return true;
    }

    console.log('ECharts-GL已通过静态导入加载');

    // 确保已正确挂载到echarts对象上
    if (!(echarts as any).gl) {
      console.log('尝试手动注册GL组件...');

      // 如果由于某些原因未挂载，尝试使用注册方法
      if (typeof echarts.use === 'function') {
        console.log('尝试使用echarts.use注册GL组件');
        // echarts-gl已经导入，这里应该会被自动挂载
        // 触发全局事件告知系统GL组件已加载完成
        const event = new CustomEvent('echarts-gl-loaded', {
          detail: { timestamp: Date.now(), fromStatic: true }
        });
        window.dispatchEvent(event);
      }
    }

    return true;
  } catch (error) {
    console.error('确认GL模块加载时出错:', error);
    return false;
  }
};

/**
 * 确保ECharts-GL组件已加载
 * 由于使用静态导入，此函数主要用于兼容性目的
 */
export const loadEChartsGL = async (): Promise<boolean> => {
  // 由于使用静态导入，我们假设GL库始终可用
  return executeGLModuleLoad();
};

/**
 * 兼容性函数，保留但不再有实际加载功能
 * 仅用于提供与旧代码的兼容性
 */
const loadViaScriptTag = (): Promise<boolean> => {
  return Promise.resolve(true); // 始终返回成功，因为已通过静态导入加载
};

/**
 * 预加载常用ECharts扩展
 * 仅用于兼容性目的，实际上已通过静态导入加载
 */
export const preloadEChartsExtensions = async (): Promise<void> => {
  try {
    // 确保echarts已经完全初始化
    await new Promise(resolve => setTimeout(resolve, 500));

    // 检查GL组件是否正确加载
    if (hasGLComponentsLoaded()) {
      console.log('GL组件已通过静态导入正确加载');
    } else {
      console.warn('GL组件可能未正确加载，尝试手动初始化');
      await executeGLModuleLoad();
    }
  } catch (error) {
    console.warn('检查ECharts扩展加载状态时出错:', error);
  }
};

/**
 * 初始化ECharts环境
 * 在应用启动时调用一次
 */
export const initEChartsEnvironment = (): void => {
  // 设置默认渲染模式 - 修复类型错误
  // echarts.init不直接支持defaultRenderer属性，需要使用类型断言
  (echarts as any).init.defaultRenderer = 'canvas';

  // 确保在window对象上也能访问echarts
  if (typeof window !== 'undefined') {
    window.echarts = echarts;
    console.log('Echarts已注册到window对象');
  }

  // 触发GL库加载完成事件
  if (hasGLComponentsLoaded()) {
    const event = new CustomEvent('echarts-gl-loaded', {
      detail: { timestamp: Date.now(), fromStatic: true }
    });
    window.dispatchEvent(event);
  }

  // 确保echarts在刷新后重新初始化
  if (typeof window !== 'undefined' && typeof document !== 'undefined') {
    const refreshEchartsInstances = () => {
      const instances = echarts.getInstanceByDom ?
        Object.values(echarts.instances || {}) : [];

      if (instances.length > 0) {
        console.log(`刷新 ${instances.length} 个ECharts实例`);
        instances.forEach((instance: any) => {
          if (instance && !instance.isDisposed() && typeof instance.resize === 'function') {
            instance.resize();
          }
        });
      }
    };

    // 页面可见性变化时刷新图表
    document.addEventListener('visibilitychange', () => {
      if (document.visibilityState === 'visible') {
        setTimeout(refreshEchartsInstances, 200);
      }
    });
  }
};

// 打印echarts版本信息
console.log('Echarts版本:', echarts.version);

// 确保导出的是完整的echarts对象
export default echarts;
